#include "SeqList.h"

#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

typedef int SLDateType;
typedef struct SeqList
{
	SLDateType* a;
	int size;
	int capacity;
}SeqList;

// 对数据的管理:增删查改 
void SeqListInit(SeqList* ps);
void SeqListDestroy(SeqList* ps);

void SeqListPrint(SeqList* ps);
void SeqListPushBack(SeqList* ps, SLDateType x);
void SeqListPushFront(SeqList* ps, SLDateType x);
void SeqListPopFront(SeqList* ps);
void SeqListPopBack(SeqList* ps);

// 顺序表查找
int SeqListFind(SeqList* ps, SLDateType x);
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x);
// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos);
//
//void _CheckCacpity(SeqList* ps) {
//	assert(ps);
//	if (ps->capacity == ps->size) {
//		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
//		ps->a = (SLDateType*)realloc(ps->a, sizeof(SLDateType) * newcapacity);
//		ps->capacity = newcapacity;
//	}
//}
//
//void SeqListInit(SeqList* ps){
//	ps->a = NULL;
//	ps->capacity = 0;
//	ps->size = 0;
//}
//
//void SeqListDestroy(SeqList* ps){
//	assert(ps);
//	free(ps->a);
//	ps->a = NULL;
//	ps->capacity = 0;
//	ps->size = 0;
//}
//
//void SeqListPrint(SeqList* ps){
//	assert(ps);
//
//	int size = ps->size;
//
//	for (int i = 0; i < size; ++i) {
//		printf("%d ", ps->a[i]);
//	}
//	printf("\n");
//}
//
//void SeqListPushBack(SeqList* ps, SLDateType x){
//	assert(ps);
//	SeqListInsert(ps, ps->size, x);
//}
//
//int SeqListFind(SeqList* ps, SLDateType x){
//	assert(ps);
//	for (int i = 0; i < ps->size; ++i) {
//		if (ps->a[i] == x) {
//			return i;
//		}
//	}
//	return -1;
//}
//
//void SeqListInsert(SeqList* ps, int pos, SLDateType x){
//	assert(ps);
//	assert(pos < ps->size);
//	_CheckCacpity(ps);
//
//	int end = ps->size;
//	while (end) {
//		ps->a[end] = ps->a[end - 1];
//		--end;
//	}
//	ps->a[pos] = x;
//	(ps->size)++;
//}
//
//void SeqListErase(SeqList* ps, int pos){
//	assert(ps);
//	assert(pos < ps->size);
//
//	int start = pos + 1;
//	while (start < ps->size) {
//		ps->a[start - 1] = ps->a[start];
//		start++;
//	}
//	(ps->size)--;
//}
//
//
//
//




//int main() {

//	//二维数组
//	int a[3][4] = { 0 };
//	printf("%d\n", sizeof(a));					//整个数组大小 48
//	printf("%d\n", sizeof(a[0][0]));			//第一个元素的第一个元素的大小 int大小 4
//	printf("%d\n", sizeof(a[0]));				//第一个元素大小 int[4] 大小 16
//	printf("%d\n", sizeof(a[0] + 1));			//a[0] + 1 是第一个元素的第二个元素的地址 8
//	printf("%d\n", sizeof(*(a[0] + 1)));		//第一个元素的第二个元素的大小 4
//	printf("%d\n", sizeof(a + 1));				//第二个元素的地址 8
//	printf("%d\n", sizeof(*(a + 1)));			//第二个元素的地址解引用的大小 16
//	printf("%d\n", sizeof(&a[0] + 1));			//第二个元素的地址 8
//	printf("%d\n", sizeof(*(&a[0] + 1)));		//第二个元素的大小 16
//	printf("%d\n", sizeof(*a));					//a没有单独在sizeof那就是第一个元素的地址，也就是
//	//对第一个元素地址解引用 16
//	printf("%d\n", sizeof(a[3]));				//第四个元素的大小 16 但是数组只有三个元素 越界了但是计算大小是用类型计算
//
//	// 48 4 16 8 4 8 16 8 16 16 16
//
//	return 0;
//}

//***************************************************

//	int a[3][4] = { 0 };
//	printf("%d\n", sizeof(a));					//整个数组大小 48
//	printf("%d\n", sizeof(a[0][0]));			//首元素的首元素大小 4
//	printf("%d\n", sizeof(a[0]));				//首元素大小 16
//	printf("%d\n", sizeof(a[0] + 1));			//a[0] 的首元素地址+1 也就是a[0][1]的地址 大小 8
//	printf("%d\n", sizeof(*(a[0] + 1)));		//第二个元素大小 16
//	printf("%d\n", sizeof(a + 1));				//第二个元素地址大小 8
//	printf("%d\n", sizeof(*(a + 1)));			//第二个元素大小 16
//	printf("%d\n", sizeof(&a[0] + 1));			//第二个元素地址 8
//	printf("%d\n", sizeof(*(&a[0] + 1)));		//第二个元素大小 16
//	printf("%d\n", sizeof(*a));					//首元素大小 16
//	printf("%d\n", sizeof(a[3]));				//第四个元素大小 16

// 48 4 16 8 4 8 16 8 16 16 16


#include"SeqList.h"

//int** generate(int numRows, int* returnSize, int** returnColumnSizes) {
//    *returnSize = numRows;
//
//    int** arr = (int**)malloc(numRows * sizeof(int*));
//
//    *returnColumnSizes = (int*)malloc(numRows * sizeof(int));
//
//    for (int i = 0; i < numRows; ++i) {
//        arr[i] = (int*)malloc((i + 1) * sizeof(int));
//        (*returnColumnSizes)[i] = i + 1;
//        for (int j = 0; j <= i; ++j) {
//            if (j == 0 || i == j) {
//                arr[i][j] == 1;
//            }
//            else {
//                arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
//            }
//        }
//    }
//
//    return arr;
//}

//
//void generate(int n) {
//    //先打印一行
//    int arr[30] = { 1 };
//    printf("1\n");
//
//    for (int i = 1; i < n; ++i) {
//        for (int j = i; j > 0; --j) {
//            arr[j] += arr[j - 1];
//        }
//        //打印
//        for (int j = 0; j <= i; ++j) {
//            printf("%d ", arr[j]);
//        }
//        printf("\n");
//    }
//}


//void leftRound(char* str, int k) {
//	int len = sizeof(str);
//	k %= len;
//	while (k--) {
//		char tmp = *str;
//		for (int i = 0; i < len - 1; ++i) {
//			*(str + i) = *(str + i + 1);
//		}
//		*(str + len - 1) = tmp;
//	}
//}

//void reverse(char* left, char* right) {
//	if (left < right) {
//		char tmp = *left;
//		*left = *right;
//		*right = tmp;
//
//		left++;
//		right--;
//	}
//}
//
//void leftRound(char* str, int k) {
//	int len = strlen(str);
//	k %= len;
//
//	reverse(str, str + k - 1);
//	reverse(str + k, str + len - 1);
//	reverse(str, str + len - 1);
//}

int findRound(const char* str1, char* str2) {
	int len2 = strlen(str2);

	int j = len2;
	while (j--) {
		char tmp = *str2;
		for (int i = 0; i < len2 - 1; ++i) {
			*(str2 + i) = *(str2 + i + 1);
		}
		*(str2 + len2 - 1) = tmp;

		if (strcmp(str1, str2) == 0) {
			return 1;
		}
	}
	return 0;
}

void swap(char* s1, char* s2, int type_size) {
	while (type_size--) {
		char tmp = *s1;
		*s1 = *s2;
		*s2 = tmp;
		s1++;
		s2++;
	}
}

int cmp(void* c1, void* c2) {
	return *(int*)c1 - *(int*)c2;
}

void my_qsort(void* arr, int size, int type_size, int(*cmp)(void*, void*)) {
	for (int i = 0; i < size - 1; ++i) {
		for (int j = 0; j < size - i - 1; ++j) {
			if (cmp(((char*)arr + (j * type_size)), ((char*)arr + ((j + 1) * type_size))) > 0) {
				swap(((char*)arr + (j * type_size)), ((char*)arr + ((j + 1) * type_size)), type_size);
			}
		}
	}
}

#define OFFSEROF(type,member)  ((size_t)&(type*)0->(member))

enum state {
	HF,
	FF
}state = FF;

int my_atoi(const char* str) {
	assert(str);

	if (*str == '\0') {
		return 0;
	}

	while (isspace(*str)) {
		str++;
	}

	int flag = 1;

	if (*str == '+') {
		str++;
	}
	else if (*str == '-') {
		flag = -1;
		str++;
	}

	long long ret = 0;
	while (*str) {
		if (isdigit(*str)) {
			//正常数字符
			ret = ret * 10 + flag * (*str - '0');

			if (ret < INT_MIN || ret > INT_MAX) {
				return 0;
			}
		}
		else {
			return ret;
		}
		str++;
	}
	state = HF;
	return ret;
}

int main() {
	/*int arr[] = { 1,4,7,2,5,8,3,6,9 };
	int len = sizeof(arr)/sizeof(int);
	my_qsort(arr, len, sizeof(int), cmp);
	for (int i = 0; i < len; ++i) {
		printf("%d ", arr[i]);
	}*/
    //generate(5);
	char s[] = "   1234555gg";
	printf("%d \n", my_atoi(s));
	return 0;
}
